This commit updates TypeScript compiler options in Storybook-related
configuration files to support Storybook 10.x's module resolution
requirements.

Problem:
Storybook 10.x changed its package structure to use subpath exports
(e.g., 'storybook/manager-api', 'storybook/theming'). These subpath
exports require modern TypeScript module resolution strategies to work
correctly. The legacy 'node' module resolution strategy doesn't
understand package.json 'exports' fields, causing TypeScript to fail
resolving Storybook imports.

Changes:
- Changed moduleResolution from 'node' to 'bundler' in both
  .storybook/tsconfig.json and src/stories/tsconfig.json
- Added 'allowImportingTsExtensions: true' to support TypeScript
  extension imports in bundler mode
- Added 'noEmit: true' since these configs are for type-checking only,
  not compilation

This fixes the underlying module resolution issues that were causing
ESLint's TypeScript parser to fail during the lint-ci step.

Files modified:
- extensions/ql-vscode/.storybook/tsconfig.json
- extensions/ql-vscode/src/stories/tsconfig.json

This commit removes redundant 'await' keywords inside a Promise.all()
call that were causing ESLint errors.

Problem:
ESLint rule '@typescript-eslint/await-thenable' detected that the code
was using 'await' on expressions that were already being passed to
Promise.all(). This is redundant and incorrect:

  await Promise.all([
    await this.cli.bqrsDecode(...),  // ❌ redundant await
    await this.cli.bqrsDecode(...),  // ❌ redundant await
    await this.cli.bqrsDecode(...),  // ❌ redundant await
  ]);

The 'await' inside the array causes each promise to be awaited
sequentially before being added to the array, defeating the purpose
of Promise.all() which is to run them in parallel. ESLint's stricter
type checking (enabled by the Storybook 10 upgrade) now catches this.

Solution:
Remove the redundant 'await' keywords inside the Promise.all() array.
The outer 'await Promise.all(...)' is sufficient:

  await Promise.all([
    this.cli.bqrsDecode(...),  // ✓ returns Promise
    this.cli.bqrsDecode(...),  // ✓ returns Promise
    this.cli.bqrsDecode(...),  // ✓ returns Promise
  ]);

This fixes 3 ESLint errors:
  src/language-support/ast-viewer/ast-builder.ts:36:7
  src/language-support/ast-viewer/ast-builder.ts:37:7
  src/language-support/ast-viewer/ast-builder.ts:38:7

File modified:
- extensions/ql-vscode/src/language-support/ast-viewer/ast-builder.ts

This commit fixes incorrect usage of Promise.all() where non-Promise
values were being passed, causing ESLint errors.

Problem:
The restartQueryServer command was passing an array to Promise.all()
containing:
1. A Promise (queryRunner.restartQueryServer)
2. Either a Promise or an empty object {} (conditional expression)
3. An async function (not invoked, so not a Promise)

ESLint rule '@typescript-eslint/await-thenable' detected this error:
  src/extension.ts:200:11
  Unexpected iterable of non-Promise (non-"Thenable") values passed
  to promise aggregator

The issues were:
- Line 199: Using `{}` as a fallback instead of a resolved Promise
- Line 200: Declaring an async function but not invoking it (missing
  the `()` to actually call the function and get its Promise)

Solution:
1. Replace `{}` with `Promise.resolve()` to maintain type consistency
2. Wrap the async function in an IIFE (Immediately Invoked Function
   Expression) by adding `()` at the end: `(async () => { ... })()`

This ensures Promise.all() receives an array of actual Promise objects,
allowing it to properly await all operations in parallel.

File modified:
- extensions/ql-vscode/src/extension.ts

This commit fixes incorrect type signatures and Promise handling for
query server event handlers that were causing ESLint errors.

Problem:
The queryServerStartListeners were typed to return 'void', but actual
usage in the codebase shows they can be async functions returning
'Promise<void>'. This mismatch caused two issues:

1. Type mismatch: The onStart() method in query-runner.ts accepts
   callbacks typed as '(progress) => Promise<void>', but the listener
   registration was typed as '(progress) => void'

2. ESLint error at line 163: When calling Promise.all() on the array
   of handler results, ESLint detected that handlers might return void
   instead of Promise, triggering '@typescript-eslint/await-thenable':
   'Unexpected iterable of non-Promise values passed to promise
   aggregator'

Solution:
1. Update type signatures to allow both synchronous (void) and
   asynchronous (Promise<void>) handlers:
   - Changed listener array type from '() => void' to
     '() => void | Promise<void>'
   - Updated onDidStartQueryServer parameter type to match

2. Wrap handler invocations in Promise.resolve() to ensure they always
   return a Promise, regardless of whether the handler is sync or async:
   - Changed: handler(progress)
   - To: Promise.resolve(handler(progress))

This makes Promise.all() safe to use with mixed sync/async handlers
while maintaining backward compatibility with existing code.

File modified:
- extensions/ql-vscode/src/query-server/query-server-client.ts

This commit fixes incorrect usage of Promise.all() where the mapped
array could contain undefined values mixed with Promises, causing
ESLint errors.

Problem:
The downloadDatabaseUpdateFromGitHub function was passing an array to
Promise.all() where map callbacks could return either:
- undefined (when no update is found for a database)
- A Promise<void> (from the withProgress call)

ESLint rule '@typescript-eslint/await-thenable' detected this error at
line 172: 'Unexpected iterable of non-Promise (non-"Thenable") values
passed to promise aggregator'

The code pattern was:
  await Promise.all(
    selectedDatabases.map((database) => {
      const update = updates.find(...);
        return;  // ❌ returns undefined
      }
      return withProgress(...);  // ✓ returns Promise
    })
  );

This creates an array like [Promise, undefined, Promise, undefined]
which violates Promise.all()'s type contract expecting all Promises.

Solution:
1. Change early return from 'return;' to 'return undefined;' for
   explicit clarity
2. Filter out undefined values before passing to Promise.all() using a
   type guard:
   .filter((p): p is Promise<void> => p !== undefined)

This ensures Promise.all() receives only actual Promise objects while
maintaining the same runtime behavior (skipping databases without
updates).

File modified:
- extensions/ql-vscode/src/databases/github-databases/updates.ts

This commit fixes TypeScript type errors in view components caused by
breaking changes in the @vscode-elements/react-elements library that
was updated as part of the Storybook 10 upgrade.

Problem:
The @vscode-elements/react-elements library changed its event handler
types and component prop APIs:

1. Event handlers now expect native DOM Event types (Event, InputEvent)
   instead of React's synthetic event types (ChangeEvent<T>). The
   library uses Lit web components which emit native events, not React
   synthetic events.

2. VscodeButton's API changed from `appearance="primary"` to
   `secondary={false}` for primary button styling.

3. Component refs must use specific element types (HTMLDivElement)
   instead of generic HTMLElement | undefined.

TypeScript Errors Fixed:
- 11 event handler type mismatches where code used ChangeEvent or
  InputEvent when Event was expected
- 1 VscodeButton prop error (appearance doesn't exist)
- 4 ref type errors (HTMLElement | undefined vs HTMLDivElement)

Changes by Category:

Event Handler Fixes:
- CodeFlowsDropdown.tsx: Changed ChangeEvent<HTMLSelectElement> to Event
- ModelTypeTextbox.tsx: Changed ChangeEvent<HTMLSelectElement> to InputEvent
- ModelAlertsSort.tsx: Changed InputEvent to Event
- RepositoriesFilter.tsx: Changed InputEvent to Event
- RepositoriesResultFormat.tsx: Changed InputEvent to Event
- RepositoriesSort.tsx: Changed InputEvent to Event
- RepoRow.tsx: Changed ChangeEvent<HTMLInputElement> to Event

All event handlers now cast e.target to the appropriate element type
(HTMLSelectElement, HTMLInputElement) to access properties like .value
and .checked.

Component API Fixes:
- VariantAnalysisActions.tsx: Changed `appearance="primary"` to
  `secondary={false}` on VscodeButton

Ref Type Fixes:
- DataGrid.tsx: Changed DataGridRow and DataGridCell ref types from
  `React.Ref<HTMLElement | undefined>` to `React.Ref<HTMLDivElement>`
- TextButton.tsx: Made $size prop optional in styled component
- MethodRow.tsx: Changed ModelableMethodRow and UnmodelableMethodRow
  forwardRef types from `HTMLElement | undefined` to `HTMLDivElement`,
  and changed useRef from `useRef<HTMLElement | undefined>(undefined)`
  to `useRef<HTMLDivElement>(null)`

These changes align the codebase with the updated @vscode-elements
library APIs while maintaining the same runtime behavior.

Files modified:
- extensions/ql-vscode/src/view/common/CodePaths/CodeFlowsDropdown.tsx
- extensions/ql-vscode/src/view/common/DataGrid.tsx
- extensions/ql-vscode/src/view/common/TextButton.tsx
- extensions/ql-vscode/src/view/model-alerts/ModelAlertsSort.tsx
- extensions/ql-vscode/src/view/model-editor/MethodRow.tsx
- extensions/ql-vscode/src/view/model-editor/ModelTypeTextbox.tsx
- extensions/ql-vscode/src/view/variant-analysis/RepoRow.tsx
- extensions/ql-vscode/src/view/variant-analysis/RepositoriesFilter.tsx
- extensions/ql-vscode/src/view/variant-analysis/RepositoriesResultFormat.tsx
- extensions/ql-vscode/src/view/variant-analysis/RepositoriesSort.tsx
- extensions/ql-vscode/src/view/variant-analysis/VariantAnalysisActions.tsx